#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
语音命令处理器 - 核心功能演示

本脚本专注于展示VoiceCommandProcessor的复杂指令处理核心功能，
包括指令分解、文本提取和意图识别，不依赖系统控制器等外部组件。
"""

import os
import sys
import re
from datetime import datetime

def clear_screen():
    """清屏函数"""
    os.system('cls' if os.name == 'nt' else 'clear')

def print_title():
    """打印标题"""
    clear_screen()
    print("=" * 80)
    print("语音命令处理器 - 复杂指令处理核心功能演示".center(70))
    print("=" * 80)
    print()
    print("本演示展示了通过语音结合大模型实现复杂指令操作的核心能力")
    print("即使在没有系统控制器的情况下，也能正确分解和处理复杂指令")
    print()

def _extract_text_parameters(text):
    """提取文本参数（从voice_command_processor.py复制的核心逻辑）"""
    # 支持单引号和双引号的文本提取
    quoted_pattern = r"['\"](.*?)['\"]"
    quoted_match = re.search(quoted_pattern, text)
    if quoted_match:
        return quoted_match.group(1).strip()
    
    # 检查是否包含复杂指令步骤
    steps = _split_complex_command(text)
    if len(steps) > 1:
        for step in steps:
            if any(keyword in step for keyword in ['输入', '写入', '打字', '录入']):
                # 提取步骤中的文本内容
                step_lower = step.lower()
                for keyword in ['输入', '写入', '打字', '录入']:
                    if keyword in step_lower:
                        start_idx = step_lower.find(keyword) + len(keyword)
                        text_content = step[start_idx:].strip()
                        if text_content:
                            return text_content
    
    # 多关键词文本提取
    text_keywords = ['输入', '写入', '打字', '录入']
    for keyword in text_keywords:
        if keyword in text:
            start_idx = text.find(keyword) + len(keyword)
            text_content = text[start_idx:].strip()
            if text_content:
                return text_content
    
    # 核心内容提取作为后备方案
    # 移除常见的命令前缀和修饰词
    prefixes = ['请', '帮我', '帮', '我需要', '我想要', '需要', '想要']
    content = text.strip()
    for prefix in prefixes:
        if content.startswith(prefix):
            content = content[len(prefix):].strip()
    
    return content

def _split_complex_command(command):
    """分割复杂命令（从voice_command_processor.py复制的核心逻辑）"""
    # 使用中文标点符号和常见的连接词分割
    split_patterns = [
        '[,，]\s*然后',
        '[,，]\s*接着', 
        '[,，]\s*再',
        '[,，]\s*之后',
        '先\s*[,，]?\s*',
        '然后\s*[,，]?\s*',
        '接着\s*[,，]?\s*',
        '再\s*[,，]?\s*',
        '[,，]\s*最后',
        '[,，]'
    ]
    
    current_command = command.strip()
    steps = []
    
    # 应用分割模式
    for pattern in split_patterns:
        if len(steps) > 0:
            break
            
        parts = re.split(pattern, current_command)
        # 确保分割后的部分不为空且数量适中（2-5个步骤）
        valid_parts = [part.strip() for part in parts if part.strip()]
        if 2 <= len(valid_parts) <= 5:
            steps = valid_parts
            break
    
    # 如果没有通过模式分割成功，尝试简单的标点分割
    if not steps:
        # 先尝试按逗号分割
        parts = re.split('[，,]', current_command)
        valid_parts = [part.strip() for part in parts if part.strip()]
        if 2 <= len(valid_parts) <= 5:
            steps = valid_parts
    
    # 如果仍然没有分割成功，返回原始命令
    if not steps:
        steps = [current_command]
    
    return steps

def is_complex_command(command):
    """判断是否为复杂命令（从voice_command_processor.py复制的核心逻辑）"""
    # 基本长度判断
    if len(command) < 20:
        return False
    
    # 动作词检测
    action_words = ['打开', '关闭', '输入', '写入', '创建', '删除', '保存', '搜索', '查找', '浏览', '运行']
    action_count = sum(1 for word in action_words if word in command)
    if action_count < 2:
        return False
    
    # 条件词和顺序词检测
    condition_words = ['如果', '那么', '否则', '假设', '除非']
    order_words = ['先', '然后', '接着', '再', '之后', '最后', '首先']
    
    has_condition = any(word in command for word in condition_words)
    has_order = any(word in command for word in order_words)
    
    # 标点符号分隔的多部分检测
    punctuation_count = sum(1 for char in command if char in '，,。；;')
    
    # 如果满足以下任一条件，则视为复杂命令
    if (has_condition or 
        has_order or 
        punctuation_count >= 2 or 
        action_count >= 3):
        return True
    
    return False

def extract_intent(command):
    """简单的意图提取演示"""
    # 定义关键词和对应的意图
    intent_patterns = {
        'file_operation': ['打开', '关闭', '创建', '删除', '保存', '搜索', '查找', '浏览'],
        'text_processing': ['输入', '写入', '打字', '录入', '编辑', '修改'],
        'system_control': ['运行', '执行', '启动', '停止', '重启'],
        'state_query': ['是否', '完成', '成功', '失败', '结果', '状态', '情况', '告诉我']
    }
    
    # 计算每个意图的匹配得分
    scores = {}
    for intent, keywords in intent_patterns.items():
        score = sum(1 for keyword in keywords if keyword in command)
        scores[intent] = score
    
    # 找到最高得分的意图
    max_score = max(scores.values())
    if max_score == 0:
        return 'unknown', 0.0
    
    # 计算置信度（简单地将得分归一化）
    confidence = max_score / len(command) * 2  # 简单缩放
    confidence = min(confidence, 1.0)  # 确保不超过1.0
    
    # 找出得分最高的意图
    best_intent = max(scores, key=scores.get)
    return best_intent, confidence

def process_complex_command_demo(command):
    """演示复杂命令处理流程"""
    print(f"\n处理命令: {command}")
    
    # 1. 判断是否为复杂命令
    complex_flag = is_complex_command(command)
    print(f"是否为复杂命令: {'是' if complex_flag else '否'}")
    
    # 2. 分解命令（如果是复杂命令）
    steps = _split_complex_command(command)
    print(f"分解后的步骤: {steps}")
    
    # 3. 对每个步骤提取文本参数（如果需要）
    if complex_flag:
        print("\n步骤分析:")
        for i, step in enumerate(steps, 1):
            # 提取意图
            intent, confidence = extract_intent(step)
            
            # 提取文本参数（如果是文本处理意图）
            text_param = None
            if intent == 'text_processing':
                text_param = _extract_text_parameters(step)
            
            print(f"  步骤 {i}: '{step}'")
            print(f"    - 意图: {intent} (置信度: {confidence:.2f})")
            if text_param:
                print(f"    - 提取的文本: '{text_param}'")
    
    # 4. 显示模拟执行结果
    print("\n模拟执行结果:")
    if complex_flag:
        for i, step in enumerate(steps, 1):
            print(f"  ✓ 步骤 {i} 已处理: '{step}'")
    else:
        # 对于简单命令，提取意图并模拟执行
        intent, confidence = extract_intent(command)
        print(f"  - 识别意图: {intent} (置信度: {confidence:.2f})")
        
        # 模拟执行
        if intent == 'text_processing':
            text = _extract_text_parameters(command)
            print(f"  ✓ 已输入文本: '{text}'")
        elif intent == 'state_query':
            print(f"  ✓ 操作已成功执行")
        else:
            print(f"  ✓ 已执行 {intent} 操作")
    
    print()

def run_demo():
    """运行演示"""
    print_title()
    
    # 演示案例
    demo_cases = [
        # 简单命令
        "输入 '这是一个测试'",
        
        # 复杂命令
        "打开记事本，然后输入文本 '这是一个复杂指令测试'，最后告诉我是否成功",
        "先打开浏览器，接着访问百度，再搜索Python教程",
        "创建一个新文件，写入今天的日期，然后保存到桌面",
        "打开文档，编辑内容，保存更改，最后关闭应用",
        
        # 带条件的命令
        "如果今天是工作日，打开工作计划；否则，打开电影文件夹",
        
        # 状态查询
        "告诉我刚才的操作是否成功完成"
    ]
    
    print("演示案例:")
    for i, case in enumerate(demo_cases, 1):
        print(f"  {i}. {case}")
    print()
    
    # 处理每个演示案例
    for i, case in enumerate(demo_cases, 1):
        print(f"\n{'=' * 80}")
        print(f"演示案例 {i}/{len(demo_cases)}")
        print(f"{'=' * 80}")
        process_complex_command_demo(case)
        
        # 除了最后一个案例外，都暂停一下
        if i < len(demo_cases):
            input("按回车键继续下一个演示...")
    
    # 交互式测试
    print(f"\n{'=' * 80}")
    print("交互式测试")
    print(f"{'=' * 80}")
    print("请输入自定义命令进行测试，输入 'exit' 退出")
    
    while True:
        command = input("\n> ").strip()
        if command.lower() == 'exit':
            break
        if command:
            process_complex_command_demo(command)
    
    print("\n演示结束！")

def main():
    """主函数"""
    try:
        run_demo()
    except KeyboardInterrupt:
        print("\n\n演示已取消")
    except Exception as e:
        print(f"\n错误: {str(e)}")

if __name__ == "__main__":
    main()